home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacApp Release 10 / MacApp Release 10 - HD Ready / Libraries / Framework / Sources / UEvent.cp < prev    next >
Encoding:
Text File  |  1996-04-03  |  14.1 KB  |  522 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UEvent.cp
  3. // Copyright © 1984-96 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UEVENT__
  7. #include "UEvent.h"
  8. #endif
  9.  
  10. // MacApp
  11.  
  12. #ifndef __UCOREUTILITIES__
  13. #include "UCoreUtilities.h"
  14. #endif
  15.  
  16. #ifndef __UDISPATCHER__
  17. #include "UDispatcher.h"
  18. #endif
  19.  
  20. #ifndef __UEVENTHANDLER__
  21. #include "UEventHandler.h"
  22. #endif
  23.  
  24. // Toolbox
  25.  
  26. #ifndef __EPPC__
  27. #include <EPPC.h>
  28. #endif
  29.  
  30. #ifndef __RESOURCES__
  31. #include <Resources.h>
  32. #endif
  33.  
  34. #ifndef __TOOLUTILS__
  35. #include <ToolUtils.h>
  36. #endif
  37.  
  38. #ifndef __WINDOWS__
  39. #include <Windows.h>
  40. #endif
  41.  
  42. // ANSI
  43.  
  44. #ifndef __STDIO__
  45. #include <stdio.h>
  46. #endif
  47.  
  48.  
  49. //========================================================================================
  50. // CLASS TEvent
  51. //========================================================================================
  52. #undef Inherited
  53. #define Inherited TObject
  54.  
  55. #pragma segment MAEvtHandlerNonRes
  56. MA_DEFINE_CLASS_M1(TEvent, Inherited);
  57.  
  58. //----------------------------------------------------------------------------------------
  59. // TEvent constructor
  60. //----------------------------------------------------------------------------------------
  61. #pragma segment MAEvtHandlerRes
  62.  
  63. TEvent::TEvent() :
  64.     fIdentifier(cNoEvent),
  65.     fSource(NULL),
  66.     fHandler(NULL),
  67.     fAffectsMenus(FALSE),
  68.     fPriority(kPriorityNormal)                // Don't worry, be happy! 
  69. {
  70. }
  71.  
  72. //----------------------------------------------------------------------------------------
  73. // TEvent::IEvent: 
  74. //----------------------------------------------------------------------------------------
  75. #pragma segment MAEvtHandlerRes
  76.  
  77. void TEvent::IEvent(EventNumber itsEventNumber,
  78.                     TEventHandler* itsSource,
  79.                     TEventHandler* itsHandler)
  80. {
  81.     IObject();
  82.  
  83.     fIdentifier = itsEventNumber;
  84.     fSource = itsSource;
  85.     fHandler = itsHandler;
  86. }
  87.  
  88. //----------------------------------------------------------------------------------------
  89. // TEvent::Free: 
  90. //----------------------------------------------------------------------------------------
  91. #pragma segment MAEvtHandlerRes
  92.  
  93. TEvent::~TEvent()
  94. {
  95. #if qDebug
  96.     if (gDispatcher)
  97.     {
  98.         TEventList* eventList = gDispatcher->fEventList;
  99.         if (eventList)
  100.         {
  101.             if (eventList->GetIdentityItemNo(this) != 0)
  102.                 ProgramBreak("You are trying to free an event that is still on the event queue.");
  103.         }
  104.     }
  105. #endif
  106. }
  107.  
  108. //----------------------------------------------------------------------------------------
  109. // TEvent::GetHandler: 
  110. //----------------------------------------------------------------------------------------
  111. #pragma segment MAEvtHandlerRes
  112.  
  113. TEventHandler* TEvent::GetHandler()
  114. {
  115.     return fHandler ? fHandler : gDispatcher;
  116. }
  117.  
  118. //----------------------------------------------------------------------------------------
  119. // TEvent::ShouldFreeOnCompletion: 
  120. //----------------------------------------------------------------------------------------
  121. #pragma segment MAEvtHandlerRes
  122.  
  123. Boolean TEvent::ShouldFreeOnCompletion()
  124. {
  125.     return TRUE;
  126. }
  127.  
  128. //----------------------------------------------------------------------------------------
  129. // TEvent::IsReadyToPost: 
  130. //----------------------------------------------------------------------------------------
  131. #pragma segment MAEvtHandlerRes
  132.  
  133. Boolean TEvent::IsReadyToPost()
  134. {
  135.     return TRUE;
  136. }
  137.  
  138. //----------------------------------------------------------------------------------------
  139. // TEvent::IsReadyToExecute: 
  140. //----------------------------------------------------------------------------------------
  141. #pragma segment MAEvtHandlerRes
  142.  
  143. Boolean TEvent::IsReadyToExecute()
  144. {
  145.     return TRUE;
  146. }
  147.  
  148. //----------------------------------------------------------------------------------------
  149. // TEvent::IsRecurring: 
  150. //----------------------------------------------------------------------------------------
  151. #pragma segment MAEvtHandlerRes
  152.  
  153. Boolean TEvent::IsRecurring()
  154. {
  155.     return FALSE;
  156. }
  157.  
  158. //----------------------------------------------------------------------------------------
  159. // TEvent::Process: 
  160. //----------------------------------------------------------------------------------------
  161. #pragma segment MAEvtHandlerRes
  162.  
  163. void TEvent::Process()    
  164.  
  165. {
  166.     TEventHandler* handler = GetHandler();
  167.     
  168.     if (handler)
  169.         handler->HandleEvent(fIdentifier,fSource,this);
  170. }
  171.  
  172. #if qDebug
  173. //----------------------------------------------------------------------------------------
  174. // TEvent::ReportEvent: 
  175. //----------------------------------------------------------------------------------------
  176. #pragma segment MADebug
  177.  
  178. void TEvent::ReportEvent()
  179. {
  180. }
  181. #endif
  182.  
  183.  
  184. //========================================================================================
  185. // CLASS TToolboxEvent
  186. //========================================================================================
  187. #undef Inherited
  188. #define Inherited TEvent
  189.  
  190. #pragma segment MAEvtHandlerNonRes
  191. MA_DEFINE_CLASS_M1(TToolboxEvent, Inherited);
  192.  
  193. //----------------------------------------------------------------------------------------
  194. // TToolboxEvent::TToolboxEvent:
  195. //----------------------------------------------------------------------------------------
  196. #pragma segment ConstructorRes
  197.  
  198. TToolboxEvent::TToolboxEvent() :
  199.     fEventRecord(fEventRecords[0]),
  200.     fCharacter(fText[1]),
  201.     fDoubleEvent(FALSE)
  202. {
  203. }
  204.  
  205. //----------------------------------------------------------------------------------------
  206. // TToolboxEvent destructor
  207. //----------------------------------------------------------------------------------------
  208. #pragma segment MADestructorRes
  209.  
  210. TToolboxEvent::~TToolboxEvent()
  211. {
  212. }
  213.  
  214. //----------------------------------------------------------------------------------------
  215. // TToolboxEvent::IToolboxEvent: 
  216. //----------------------------------------------------------------------------------------
  217. #pragma segment MAEvtHandlerRes
  218.  
  219. Boolean TToolboxEvent::IToolboxEvent(TEventHandler* itsHandler,
  220.                                   const EventRecord& theEvent)
  221.  
  222. {
  223.     Boolean returnVal = FALSE;
  224.  
  225.     IEvent(cNoCommand, NULL, itsHandler);
  226.     
  227.     fIdentifier = (long) theEvent.what;
  228.     fEventRecords[0] = theEvent;
  229.     fClickCount = 0;
  230.     fText.Empty();                // Default, we don't know if this is a keystroke yet
  231.     fKeyScript = (short)GetScriptManagerVariable(smKeyScript);
  232.     fKeyCode = 0;                    // Default, we don't know if this is a keystroke yet
  233.     fAffectsMenus = TRUE;            // assume going in that this event affects the menus
  234.  
  235.     fDoubleEvent = FALSE;
  236.     // Check to see if this event is the first of a two event sequence the toolbox uses to get
  237.     // multibyte characters to us.
  238.     if ((fEventRecord.what == keyDown) || (fEventRecord.what == keyUp) || (fEventRecord.what == autoKey))
  239.     {
  240.         unsigned char theCharacter = (unsigned char)(fEventRecord.message & charCodeMask);
  241.         returnVal = MACharacterByteType((Ptr)&theCharacter, 0, fKeyScript) == smFirstByte;
  242.     }
  243.  
  244.     return returnVal;
  245. }
  246.  
  247. //----------------------------------------------------------------------------------------
  248. // TToolboxEvent::AddSecondaryKeyEvent: 
  249. //----------------------------------------------------------------------------------------
  250. #pragma segment MAEvtHandlerRes
  251.  
  252. void TToolboxEvent::AddSecondaryKeyEvent(const EventRecord& theEvent)
  253. {
  254.     fDoubleEvent = TRUE;
  255.     fEventRecords[1] = theEvent;
  256. }
  257.  
  258. //----------------------------------------------------------------------------------------
  259. // TToolboxEvent::IsButtonPressed: 
  260. //----------------------------------------------------------------------------------------
  261. #pragma segment MAEvtHandlerRes
  262.  
  263. Boolean TToolboxEvent::IsButtonPressed() const
  264. {
  265.     return ((fEventRecord.modifiers) & btnState) != 0;
  266. }
  267.  
  268. //----------------------------------------------------------------------------------------
  269. // TToolboxEvent::IsCommandKeyPressed: 
  270. //----------------------------------------------------------------------------------------
  271. #pragma segment MAEvtHandlerRes
  272.  
  273. Boolean TToolboxEvent::IsCommandKeyPressed() const
  274. {
  275.     return ((fEventRecord.modifiers) & cmdKey) != 0;
  276. }
  277.  
  278. //----------------------------------------------------------------------------------------
  279. // TToolboxEvent::IsShiftKeyPressed: 
  280. //----------------------------------------------------------------------------------------
  281. #pragma segment MAEvtHandlerRes
  282.  
  283. Boolean TToolboxEvent::IsShiftKeyPressed() const
  284. {
  285.     return ((fEventRecord.modifiers) & shiftKey) != 0;
  286. }
  287.  
  288. //----------------------------------------------------------------------------------------
  289. // TToolboxEvent::IsAlphaLock: 
  290. //----------------------------------------------------------------------------------------
  291. #pragma segment MAEvtHandlerRes
  292.  
  293. Boolean TToolboxEvent::IsAlphaLock() const
  294. {
  295.     return ((fEventRecord.modifiers) & alphaLock) != 0;
  296. }
  297.  
  298. //----------------------------------------------------------------------------------------
  299. // TToolboxEvent::IsOptionKeyPressed: 
  300. //----------------------------------------------------------------------------------------
  301. #pragma segment MAEvtHandlerRes
  302.  
  303. Boolean TToolboxEvent::IsOptionKeyPressed() const
  304. {
  305.     return ((fEventRecord.modifiers) & optionKey) != 0;
  306. }
  307.  
  308. //----------------------------------------------------------------------------------------
  309. // TToolboxEvent::IsControlKeyPressed: 
  310. //----------------------------------------------------------------------------------------
  311. #pragma segment MAEvtHandlerRes
  312.  
  313. Boolean TToolboxEvent::IsControlKeyPressed() const
  314. {
  315.     return ((fEventRecord.modifiers) & controlKey) != 0;
  316. }
  317.  
  318. //----------------------------------------------------------------------------------------
  319. // TToolboxEvent::IsAutoKeyEvent: 
  320. //----------------------------------------------------------------------------------------
  321. #pragma segment MAEvtHandlerRes
  322.  
  323. Boolean TToolboxEvent::IsAutoKeyEvent() const
  324. {
  325.     return fEventRecord.what == autoKey;
  326. }
  327.  
  328. //----------------------------------------------------------------------------------------
  329. // TToolboxEvent::Process: 
  330. //----------------------------------------------------------------------------------------
  331. #pragma segment MAEvtHandlerRes
  332.  
  333. void TToolboxEvent::Process()    
  334. {
  335.     gDispatcher->HandleToolboxEvent(this);
  336. }
  337.  
  338.  
  339. //----------------------------------------------------------------------------------------
  340. // TToolboxEvent::RemoveDependenciesOnFree: 
  341. //----------------------------------------------------------------------------------------
  342. #pragma segment MAEvtHandlerRes
  343.  
  344. Boolean TToolboxEvent::RemoveDependenciesOnFree()    
  345. {
  346.     // TToolboxEvents are short time objects that really shouldn't carry the burden of
  347.     // managing dependent objects.  Rather concentrate on the command objects that are
  348.     // generated by an event.
  349.     return FALSE;
  350. }
  351.  
  352. #if qDebug
  353. //----------------------------------------------------------------------------------------
  354. // TToolboxEvent::ReportEvent: 
  355. //----------------------------------------------------------------------------------------
  356. #pragma segment MADebug
  357.  
  358. void TToolboxEvent::ReportEvent()        // override 
  359. {
  360.     short ch;
  361.     short cap;
  362.     CStr255 aString;
  363.     CStr63 mods;
  364.     WindowRef aWMgrWindow;
  365.     CPoint localWhere;
  366.  
  367.     fprintf(stderr, "t = %d", fEventRecord.when);
  368.     mods = " ---------";
  369.     //        1234567890 
  370.  
  371.     if (IsControlKeyPressed())
  372.         mods[2] = 'C';
  373.     if (IsOptionKeyPressed())
  374.         mods[3] = 'O';
  375.     if (IsAlphaLock())
  376.         mods[4] = 'L';
  377.     if (IsShiftKeyPressed())
  378.         mods[5] = 'S';
  379.     if (IsCommandKeyPressed())
  380.         mods[6] = 'C';
  381.     if (IsButtonPressed())
  382.         mods[7] = 'M';
  383.     if (fEventRecord.what == activateEvt)
  384.         if (((fEventRecord.modifiers) & activeFlag) != 0)
  385.             mods[8] = 'A';
  386.         else
  387.             mods[8] = 'D';
  388.     fprintf(stderr, "%s", (const char*)mods);
  389.  
  390.     switch (fEventRecord.what)
  391.     {
  392.         case nullEvent:
  393.             fprintf(stderr, "nullEvent\n");
  394.             break;
  395.         case mouseDown:
  396.         case mouseUp:
  397.             if (fEventRecord.what == mouseDown)
  398.                 fprintf(stderr, "mouseDown   ");
  399.             else
  400.                 fprintf(stderr, "mouseUp     ");
  401.             fprintf(stderr, "%s", (const char*)CPoint(fEventRecord.where));
  402.             switch (FindWindow(fEventRecord.where, &aWMgrWindow))
  403.             {
  404.                 case inMenuBar:
  405.                     aString = "inMenuBar";
  406.                     break;
  407.                     
  408.                 case inSysWindow:
  409.                     aString = "inSysWindow";
  410.                     break;
  411.                     
  412.                 case inDrag:
  413.                     aString = "inDrag";
  414.                     break;
  415.                     
  416.                 case inGrow:
  417.                     aString = "inGrow";
  418.                     break;
  419.                     
  420.                 case inGoAway:
  421.                     aString = "inGoAway";
  422.                     break;
  423.                     
  424.                 case inContent:
  425.                     aString = "inContent";
  426.                     break;
  427.                     
  428.                 case inZoomIn:
  429.                     aString = "inZoomIn";
  430.                     break;
  431.                     
  432.                 case inZoomOut:
  433.                     aString = "inZoomOut";
  434.                     break;
  435.                     
  436.                 default:
  437.                     aString = "Mouse clicked in an unknown place.";
  438.                     break;
  439.             }
  440.  
  441.             fprintf(stderr, "%5s\n", (const char*)aString);
  442.             break;
  443.         case keyDown:
  444.         case autoKey:
  445.         case keyUp:
  446.             if (fEventRecord.what == keyDown)
  447.                 fprintf(stderr, "keyDown     ");
  448.             else if (fEventRecord.what == autoKey)
  449.                 fprintf(stderr, "autoKey     ");
  450.             else
  451.                 fprintf(stderr, "keyUp       ");
  452.  
  453.             ch = (short)(fEventRecord.message & charCodeMask);
  454.             cap = (short)(fEventRecord.message >> 8);
  455.  
  456.             if ((ch >= 0x20) && (ch <= 0xD8) && (ch != 0x7F))
  457.                 fprintf(stderr, "\"%c\"", ch);
  458.             else
  459.                 fprintf(stderr, "   ");
  460.  
  461.             fprintf(stderr, "( %1d / %1d )\n", ch, cap);
  462.             break;
  463.  
  464.         case updateEvt:
  465.         case activateEvt:
  466.             if (fEventRecord.what == updateEvt)
  467.                 fprintf(stderr, "updateEvt   ");
  468.             else
  469.                 fprintf(stderr, "activateEvt ");
  470.  
  471.             GetWTitle((WindowRef)(fEventRecord.message), aString);
  472.             fprintf(stderr, "\"%s\"\n", (const char*)aString);
  473.             break;
  474.  
  475.         case diskEvt:
  476.             fprintf(stderr, "diskEvt     d = %1d e = %1d \n", LoWord(fEventRecord.message), HiWord(fEventRecord.message));
  477.             break;
  478.  
  479.         case osEvt:
  480.             switch ((((fEventRecord.message) & osEvtMessageMask)) >> 24)
  481.             {
  482.                 case suspendResumeMessage:
  483.                     if (fEventRecord.message & 1)
  484.                         fprintf(stderr, "resume      ");
  485.                     else
  486.                         fprintf(stderr, "suspend     ");
  487.                     break;
  488.                     
  489.                 case mouseMovedMessage:
  490.                 {
  491.                     fprintf(stderr, "mouse moved ");
  492.                     fprintf(stderr, "%s", (const char*)CPoint(fEventRecord.where));
  493.                     break;
  494.                 }
  495.                     
  496.                 default:
  497.                     fprintf(stderr, "osEvt     ");
  498.                     break;
  499.             }
  500.             WrLblHexLongint(", message", fEventRecord.message);
  501.             fprintf(stderr, "\n");
  502.             break;
  503.             
  504.         case kHighLevelEvent:
  505.             WrLblHexLongint("kHighLevelEvent     , message", fEventRecord.message);
  506.             fprintf(stderr, "\n");
  507.             break;
  508.             
  509.         default:
  510.             fprintf(stderr, "??? unknown = %1d   ", fEventRecord.what);
  511.             WriteHexLongint(fEventRecord.message);
  512.             break;
  513.     }
  514. }
  515.  
  516. #endif
  517.  
  518. //----------------------------------------------------------------------------------------
  519. // End of UEvent.cp
  520.  
  521. #pragma segment Inline
  522.